package com.aaa.power.service.impl;

import com.aaa.common.bo.TreeNode;
import com.aaa.common.bo.User;
import com.aaa.common.constants.ReturnCode;
import com.aaa.common.util.Result;
import com.aaa.power.dao.MenuDao;
import com.aaa.power.entity.Menu;
import com.aaa.power.service.MenuService;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.data.redis.core.RedisTemplate;
import org.springframework.stereotype.Service;

import javax.annotation.Resource;
import java.util.ArrayList;
import java.util.List;

/**
 * 菜单权限表(Menu)表服务实现类
 *
 * @author makejava
 * @since 2020-11-09 20:05:04
 */
@Service("menuService")
public class MenuServiceImpl implements MenuService {
    @Resource
    private MenuDao menuDao;

    @Autowired
    private RedisTemplate redisTemplate;

    /**
     * 通过ID查询单条数据
     *
     * @param menuId 主键
     * @return 实例对象
     */
    @Override
    public Menu queryById(Integer menuId) {
        return this.menuDao.queryById(menuId);
    }

    @Override
    public List<TreeNode> queryAllToTreeData() {
        //把Menu集合转换为List<TreeNode>
        List<Menu> menus = menuDao.queryAll(null);
        System.out.println(menus);
        //实例化集合，用于接受数据
        List<TreeNode> treeNodes = new ArrayList<>();
        //判断
        if(menus!=null&&menus.size()>0){
            TreeNode treeNode = null;
            //循环
            for (Menu menu : menus) {
                //查找一级节点
                if(menu.getParentId()==0) {
                    treeNode = this.menuToTreeNod(menu);
                    //查找子节点
                    bindChildren(treeNode,menus);
                    //添加节点
                    treeNodes.add(treeNode);
                }
            }
        }
        return treeNodes;
    }

    /**
     * 根据token查询用户信息，再根据用户ID查询该用户的拥有的全选菜单
     * @param token
     * @return
     */
    @Override
    public List<TreeNode> selectMenuByToken(String token) {
        System.out.println("token为："+token);
        System.out.println(redisTemplate.opsForValue().get(token));
        //从redis数据库中用token查询到user
        User user = (User) redisTemplate.opsForValue().get(token);
        System.out.println(user);
        List<TreeNode> treeNodes = menuDao.queryMenuByUserId(user.getUserId());
        System.out.println();
        List<TreeNode> treeNodes1 = new ArrayList<>();
        if(treeNodes != null&&treeNodes.size()>0){
            for(TreeNode node : treeNodes){
                //if(node.getParentId() == 0){
                    bindChildren2(node,treeNodes);
                    treeNodes1.add(node);
                //}
            }
        }
        System.out.println(treeNodes+"你好年底了");
        return treeNodes1;
    }

    /**
     * 对象转换
     * @param menu
     * @return
     */
    private TreeNode menuToTreeNod(Menu menu){
        TreeNode treeNode = new TreeNode();
        treeNode.setId(menu.getMenuId());
        treeNode.setParentId(menu.getParentId());
        treeNode.setLabel(menu.getMenuName());
        treeNode.setIcon(menu.getIcon());
        treeNode.setUrl(menu.getUrl());
        treeNode.setParentName(menu.getParentName());
        return treeNode;
    }
    /**
     * 递归绑定子节点
     * @param currentNode
     * @param menus
     */
    private void bindChildren(TreeNode currentNode, List<Menu> menus){
        //循环
        for (Menu menu : menus) {
            //如果说循环节点的父ID等于当前节点的ID，说明循环节点是当前的节点孩子
            if(currentNode.getId()==menu.getParentId()){
                //获取孩子集合（第一次获取时肯定是空对象）
                List<TreeNode> children = currentNode.getChildren();
                //为空实例化对象
                if(children==null){
                    children = new ArrayList<>();
                }
                TreeNode treeNode = this.menuToTreeNod(menu);
                //添加孩子
                children.add(treeNode);
                //绑定
                currentNode.setChildren(children);
                //自己调用自己，查找孩子
                bindChildren(treeNode,menus);
            }
        }

    }

    /**
     * 递归绑定子节点
     * @param currentNode
     * @param treeNodes
     */
    private void bindChildren2(TreeNode currentNode, List<TreeNode> treeNodes){
        //循环
        for (TreeNode treeNode : treeNodes) {
            //如果说循环节点的父ID等于当前节点的ID，说明循环节点是当前的节点孩子
            if(currentNode.getId()==treeNode.getParentId()){
                //获取孩子集合（第一次获取时肯定是空对象）
                List<TreeNode> children = currentNode.getChildren();
                //为空实例化对象
                if(children==null){
                    children = new ArrayList<>();
                }
                //添加孩子
                children.add(treeNode);
                //绑定
                currentNode.setChildren(children);
                //自己调用自己，查找孩子
                bindChildren2(treeNode,treeNodes);
            }
        }

    }

    /**
     * 查询多条数据
     *
     * @param offset 查询起始位置
     * @param limit  查询条数
     * @return 对象列表
     */
    @Override
    public List<Menu> queryAllByLimit(int offset, int limit) {
        return this.menuDao.queryAllByLimit(offset, limit);
    }

    /**
     * 新增数据
     *
     * @param menu 实例对象
     * @return 实例对象
     */
    @Override
    public Menu insert(Menu menu) {
        this.menuDao.insert(menu);
        return menu;
    }

    /**
     * 修改数据
     *
     * @param menu 实例对象
     * @return 实例对象
     */
    @Override
    public Menu update(Menu menu) {
        this.menuDao.update(menu);
        return this.queryById(menu.getMenuId());
    }

    /**
     * 通过主键删除数据
     *
     * @param menuId 主键
     * @return 是否成功
     */
    @Override
    public boolean deleteById(Integer menuId) {
        return this.menuDao.deleteById(menuId) > 0;
    }

    @Override
    public Result queryUrlNotNull() {
        Menu menu = new Menu();
        //url非空
        menu.setIsNullUrl(1);
        //非隐藏菜单
        menu.setVisible("0");
        return new Result(ReturnCode.SUCCESSS.getCode(),
                ReturnCode.SUCCESSS.getMsg(),this.menuDao.queryAll(menu));
    }
}